2025 m. rugsėjo 22 d.Lietuvių

Pandas DataFrame sujungimas: vadovas. Išmokite vidinius, išorinius, kairiuosius, dešiniuosius sujungimus su pavyzdžiais duomenų analizei.

Python Pandas apjungimas: „DataFrame“ sujungimo strategijų įvaldymas duomenų analizei

Duomenų manipuliavimas yra esminis duomenų analizės aspektas, o Python Pandas biblioteka suteikia galingus įrankius šiam tikslui. Tarp šių įrankių, „DataFrame“ sujungimas ir apjungimas yra būtinos operacijos, skirtos derinti duomenų rinkinius pagal bendras stulpelius ar indeksus. Šis išsamus vadovas nagrinėja įvairias „DataFrame“ sujungimo strategijas Pandas, suteikdamas jums žinių, kaip efektyviai derinti ir analizuoti duomenis iš skirtingų šaltinių.

„DataFrame“ sujungimo ir apjungimo supratimas

„DataFrame“ sujungimas ir apjungimas apima dviejų ar daugiau „DataFrame“ sujungimą į vieną „DataFrame“ pagal bendrą stulpelį arba indeksą. Pagrindinis skirtumas tarp `merge` ir `join` yra tas, kad `merge` yra Pandas bibliotekos funkcija ir paprastai sujungia „DataFrames“ pagal stulpelius, o `join` yra „DataFrame“ metodas, kuris sujungia „DataFrames“ daugiausia pagal indeksus, nors gali būti naudojamas ir su stulpeliais.

Pagrindinės sąvokos

DataFrames: Dvimatės žymėtos duomenų struktūros su stulpeliais, kurie gali būti skirtingų tipų.
Bendri stulpeliai/indeksai: Stulpeliai arba indeksai, turintys tą patį pavadinimą ir duomenų tipą skirtinguose „DataFrames“, tarnaujantys kaip sujungimo/apjungimo pagrindas.
Sujungimo tipai: Skirtingos strategijos, skirtos tvarkyti nesuderintas eilutes sujungimo/apjungimo proceso metu, įskaitant vidinį, išorinį, kairįjį ir dešinįjį sujungimus.

„DataFrame“ sujungimas naudojant `pd.merge()`

Funkcija `pd.merge()` yra pagrindinis įrankis, skirtas sujungti „DataFrames“ pagal stulpelius. Ji siūlo lankstų būdą derinti duomenis pagal vieną ar daugiau bendrų stulpelių.

Sintaksė

pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)

Parametrai

left: Kairysis „DataFrame“ sujungimui.
right: Dešinysis „DataFrame“ sujungimui.
how: Sujungimo tipas, kuris turi būti atliktas ('inner', 'outer', 'left', 'right'). Numatytoji reikšmė yra 'inner'.
on: Stulpelio (-ių) pavadinimas (-ai), pagal kurį (-uos) atliekamas sujungimas. Jie turi būti abiejuose „DataFrames“.
left_on: Kairiojo „DataFrame“ stulpelio (-ių) pavadinimas (-ai), naudojamas (-i) kaip sujungimo raktai.
right_on: Dešiniojo „DataFrame“ stulpelio (-ių) pavadinimas (-ai), naudojamas (-i) kaip sujungimo raktai.
left_index: Jei True, naudokite kairiojo „DataFrame“ indeksą kaip sujungimo raktą (-us).
right_index: Jei True, naudokite dešiniojo „DataFrame“ indeksą kaip sujungimo raktą (-us).
sort: Rūšiuoti rezultatų „DataFrame“ leksikografiškai pagal sujungimo raktus. Numatytoji reikšmė yra False.
suffixes: Eilučių priesagų rinkinys, kuris bus pritaikytas persidengiantiems stulpelių pavadinimams. Numatytoji reikšmė yra ('_x', '_y').
copy: Jei False, venkite kopijuoti duomenis į naują „DataFrame“, kur tai įmanoma. Numatytoji reikšmė yra True.
indicator: Jei True, prideda stulpelį pavadinimu '_merge', nurodantį kiekvienos eilutės šaltinį.
validate: Tikrina, ar sujungimas yra nurodyto tipo. "one_to_one", "one_to_many", "many_to_one", "many_to_many".

Paaiškinti sujungimo tipai

Parametras `how` funkcijoje `pd.merge()` nustato atliekamo sujungimo tipą. Skirtingi sujungimo tipai tvarko nesuderintas eilutes skirtingais būdais.

Vidinis sujungimas

Vidinis sujungimas grąžina tik tas eilutes, kurios turi sutampančias reikšmes abiejuose „DataFrames“ pagal sujungimo raktus. Eilutės su nesutampančiomis reikšmėmis yra neįtraukiamos į rezultatą.

Pavyzdys:

Apsvarstykite du „DataFrames“:

            import pandas as pd

# DataFrame 1: Customer Orders
df_orders = pd.DataFrame({
 'order_id': [1, 2, 3, 4, 5],
 'customer_id': [101, 102, 103, 104, 105],
 'product_id': [1, 2, 1, 3, 2],
 'quantity': [2, 1, 3, 1, 2]
})

# DataFrame 2: Customer Information
df_customers = pd.DataFrame({
 'customer_id': [101, 102, 103, 106],
 'customer_name': ['Alice', 'Bob', 'Charlie', 'David'],
 'country': ['USA', 'Canada', 'UK', 'Australia']
})

# Inner Join
df_inner = pd.merge(df_orders, df_customers, on='customer_id', how='inner')
print(df_inner)

Rezultatas:

             order_id  customer_id  product_id  quantity customer_name country
0         1          101           1         2         Alice     USA
1         2          102           2         1           Bob  Canada
2         3          103           1         3       Charlie      UK

Šiame pavyzdyje vidinis sujungimas sujungia `df_orders` ir `df_customers` „DataFrames“ pagal stulpelį `customer_id`. Į rezultatą įtraukiami tik tie klientai, kurie pateikė užsakymus. Klientas 'David' (customer_id 106) yra neįtraukiamas, nes jis neturi jokių užsakymų.

Išorinis sujungimas (pilnas išorinis sujungimas)

Išorinis sujungimas grąžina visas eilutes iš abiejų „DataFrames“, įskaitant nesuderintas eilutes. Jei eilutė neturi atitikmens kitame „DataFrame“, atitinkamuose stulpeliuose bus `NaN` (ne skaičius) reikšmės.

Pavyzdys:

            # Outer Join
df_outer = pd.merge(df_orders, df_customers, on='customer_id', how='outer')
print(df_outer)

Rezultatas:

               order_id  customer_id  product_id  quantity customer_name    country
0       1.0          101         1.0       2.0         Alice        USA
1       2.0          102         2.0       1.0           Bob     Canada
2       3.0          103         1.0       3.0       Charlie         UK
3       4.0          104         3.0       1.0           NaN        NaN
4       5.0          105         2.0       2.0           NaN        NaN
5       NaN          106         NaN       NaN         David   Australia

Išorinis sujungimas apima visus klientus ir visus užsakymus. Klientai 104 ir 105 turi užsakymų, bet neturi klientų informacijos, o klientas 106 turi klientų informaciją, bet neturi užsakymų. Trūkstamos reikšmės žymimos kaip `NaN`.

Kairysis sujungimas

Kairysis sujungimas grąžina visas eilutes iš kairiojo „DataFrame“ ir sutampančias eilutes iš dešiniojo „DataFrame“. Jei eilutė kairiajame „DataFrame“ neturi atitikmens dešiniajame „DataFrame“, atitinkamuose dešiniojo „DataFrame“ stulpeliuose bus `NaN` reikšmės.

Pavyzdys:

            # Left Join
df_left = pd.merge(df_orders, df_customers, on='customer_id', how='left')
print(df_left)

Rezultatas:

               order_id  customer_id  product_id  quantity customer_name country
0         1          101           1         2         Alice     USA
1         2          102           2         1           Bob  Canada
2         3          103           1         3       Charlie      UK
3         4          104           3         1           NaN     NaN
4         5          105           2         2           NaN     NaN

Kairysis sujungimas apima visus užsakymus iš `df_orders`. Klientai 104 ir 105 turi užsakymų, bet neturi klientų informacijos, todėl `customer_name` ir `country` stulpeliai yra `NaN` tiems užsakymams.

Dešinysis sujungimas

Dešinysis sujungimas grąžina visas eilutes iš dešiniojo „DataFrame“ ir sutampančias eilutes iš kairiojo „DataFrame“. Jei eilutė dešiniajame „DataFrame“ neturi atitikmens kairiajame „DataFrame“, atitinkamuose kairiojo „DataFrame“ stulpeliuose bus `NaN` reikšmės.

Pavyzdys:

            # Right Join
df_right = pd.merge(df_orders, df_customers, on='customer_id', how='right')
print(df_right)

Rezultatas:

               order_id  customer_id  product_id  quantity customer_name    country
0       1.0          101         1.0       2.0         Alice        USA
1       2.0          102         2.0       1.0           Bob     Canada
2       3.0          103         1.0       3.0       Charlie         UK
3       NaN          106         NaN       NaN         David   Australia

Dešinysis sujungimas apima visus klientus iš `df_customers`. Klientas 106 turi klientų informaciją, bet neturi užsakymų, todėl `order_id`, `product_id` ir `quantity` stulpeliai yra `NaN` tam klientui.

„DataFrame“ apjungimas naudojant `df.join()`

Metodas `df.join()` pirmiausia naudojamas „DataFrames“ apjungimui pagal jų indeksus. Jis taip pat gali būti naudojamas apjungti pagal stulpelius, tačiau `pd.merge()` paprastai yra patogesnis stulpelių pagrindu atliekamiems apjungimams.

Sintaksė

DataFrame.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False)

Parametrai

other: Kitas „DataFrame“, kurį reikia apjungti.
on: Stulpelio pavadinimas, pagal kurį apjungti. Turi būti perduotas, jei indeksas nenaudojamas kaip apjungimo raktas.
how: Kaip tvarkyti kairiojo ir dešiniojo rinkinių operaciją. Numatytoji reikšmė yra 'left'.
lsuffix: Priesaga, naudojama iš kairiojo „DataFrame“ persidengiantiems stulpelių pavadinimams pakeisti.
rsuffix: Priesaga, naudojama iš dešiniojo „DataFrame“ persidengiantiems stulpelių pavadinimams pakeisti.
sort: Rūšiuoti rezultatų „DataFrame“ leksikografiškai pagal apjungimo raktus. Numatytoji reikšmė yra False.

Apjungimas pagal indeksą

Apjungiant pagal indeksą, `on` parametras nenaudojamas.

Pavyzdys:

            # DataFrame 1: Customer Orders with Customer ID as Index
df_orders_index = df_orders.set_index('customer_id')

# DataFrame 2: Customer Information with Customer ID as Index
df_customers_index = df_customers.set_index('customer_id')

# Join on Index (Left Join)
df_join_index = df_orders_index.join(df_customers_index, how='left')
print(df_join_index)

Rezultatas:

               order_id  product_id  quantity customer_name country
customer_id                                        
101                 1           1         2         Alice     USA
102                 2           2         1           Bob  Canada
103                 3           1         3       Charlie      UK
104                 4           3         1           NaN     NaN
105                 5           2         2           NaN     NaN

Šiame pavyzdyje `join()` metodas naudojamas kairiajam apjungimui pagal indeksą (`customer_id`). Rezultatas yra panašus į kairįjį sujungimą naudojant `pd.merge()`, tačiau apjungimas pagrįstas indeksu, o ne stulpeliu.

Apjungimas pagal stulpelį

Norėdami apjungti pagal stulpelį naudodami `df.join()`, turite nurodyti `on` parametrą.

Pavyzdys:

            # Joining on a column
df_join_column = df_orders.join(df_customers.set_index('customer_id'), on='customer_id', how='left')
print(df_join_column)

Rezultatas:

               order_id  customer_id  product_id  quantity customer_name country
0         1          101           1         2         Alice     USA
1         2          102           2         1           Bob  Canada
2         3          103           1         3       Charlie      UK
3         4          104           3         1           NaN     NaN
4         5          105           2         2           NaN     NaN

Šis pavyzdys demonstruoja `df_orders` apjungimą su `df_customers` naudojant `customer_id` stulpelį. Atkreipkite dėmesį, kad `customer_id` yra nustatytas kaip `df_customers` indeksas prieš atliekant apjungimą.

Persidengiančių stulpelių tvarkymas

Sujungiant ar apjungiant „DataFrames“, dažnai pasitaiko persidengiančių stulpelių pavadinimų (stulpeliai su tuo pačiu pavadinimu abiejuose „DataFrames“). Pandas suteikia `suffixes` parametrą `pd.merge()` ir `lsuffix` bei `rsuffix` parametrus `df.join()`, kad būtų galima tvarkyti šias situacijas.

`suffixes` naudojimas `pd.merge()` funkcijoje

Parametras `suffixes` leidžia nurodyti priesagas, kurios bus pridėtos prie persidengiančių stulpelių pavadinimų, kad juos būtų galima atskirti.

Pavyzdys:

            # DataFrame 1: Product Information
df_products1 = pd.DataFrame({
 'product_id': [1, 2, 3],
 'product_name': ['Product A', 'Product B', 'Product C'],
 'price': [10, 20, 15]
})

# DataFrame 2: Product Information (with potentially updated prices)
df_products2 = pd.DataFrame({
 'product_id': [1, 2, 4],
 'product_name': ['Product A', 'Product B', 'Product D'],
 'price': [12, 18, 25]
})

# Merge with suffixes
df_merged_suffixes = pd.merge(df_products1, df_products2, on='product_id', suffixes=('_old', '_new'))
print(df_merged_suffixes)

Rezultatas:

               product_id product_name_old  price_old product_name_new  price_new
0           1      Product A         10       Product A         12
1           2      Product B         20       Product B         18

Šiame pavyzdyje `product_name` ir `price` stulpeliai yra abiejuose „DataFrames“. Parametras `suffixes` prideda priesagas `_old` ir `_new`, kad atskirtų stulpelius iš kairiojo ir dešiniojo „DataFrames“.

`lsuffix` ir `rsuffix` naudojimas `df.join()` metode

Parametrai `lsuffix` ir `rsuffix` suteikia panašų funkcionalumą `df.join()` metodui. `lsuffix` prideda prie kairiojo „DataFrame“ persidengiančių stulpelių, o `rsuffix` – prie dešiniojo „DataFrame“.

Pavyzdys:

            # Join with lsuffix and rsuffix
df_products1_index = df_products1.set_index('product_id')
df_products2_index = df_products2.set_index('product_id')
df_joined_suffixes = df_products1_index.join(df_products2_index, lsuffix='_old', rsuffix='_new', how='outer')
print(df_joined_suffixes)

Rezultatas:

                      product_name_old  price_old product_name_new  price_new
product_id                                                     
1                 Product A       10.0        Product A       12.0
2                 Product B       20.0        Product B       18.0
3                 Product C       15.0            NaN        NaN
4                       NaN        NaN        Product D       25.0

Praktiniai pavyzdžiai ir naudojimo atvejai

„DataFrames“ sujungimas ir apjungimas plačiai naudojami įvairiose duomenų analizės scenarijose. Štai keletas praktinių pavyzdžių:

Pardavimų duomenų sujungimas su produkto informacija

Dažnas naudojimo atvejis yra pardavimų duomenų sujungimas su produkto informacija. Tarkime, turite „DataFrame“, kuriame yra pardavimų operacijos, ir kitą „DataFrame“, kuriame yra produkto detalės. Šiuos „DataFrames“ galite sujungti, kad praturtintumėte pardavimų duomenis produkto informacija.

Pavyzdys:

            # Sales Transactions Data
df_sales = pd.DataFrame({
 'transaction_id': [1, 2, 3, 4, 5],
 'product_id': [101, 102, 103, 101, 104],
 'quantity': [2, 1, 3, 1, 2],
 'sales_date': ['2023-01-15', '2023-02-20', '2023-03-10', '2023-04-05', '2023-05-01']
})

# Product Information Data
df_products = pd.DataFrame({
 'product_id': [101, 102, 103, 104],
 'product_name': ['Laptop', 'Mouse', 'Keyboard', 'Monitor'],
 'category': ['Electronics', 'Electronics', 'Electronics', 'Electronics'],
 'price': [1200, 25, 75, 300]
})

# Merge Sales Data with Product Information
df_sales_enriched = pd.merge(df_sales, df_products, on='product_id', how='left')
print(df_sales_enriched)

Rezultatas:

               transaction_id  product_id  quantity sales_date product_name     category   price
0               1         101         2   2023-01-15       Laptop  Electronics  1200
1               2         102         1   2023-02-20        Mouse  Electronics    25
2               3         103         3   2023-03-10     Keyboard  Electronics    75
3               4         101         1   2023-04-05       Laptop  Electronics  1200
4               5         104         2   2023-05-01      Monitor  Electronics   300

Gautas „DataFrame“ `df_sales_enriched` apima pardavimų operacijas kartu su atitinkama produkto informacija, leidžiančia detaliau analizuoti pardavimų tendencijas ir produkto našumą.

Klientų duomenų sujungimas su demografine informacija

Kitas dažnas naudojimo atvejis yra klientų duomenų sujungimas su demografine informacija. Tai leidžia analizuoti klientų elgseną pagal demografinius veiksnius.

Pavyzdys:

            # Customer Data
df_customers = pd.DataFrame({
 'customer_id': [1, 2, 3, 4, 5],
 'customer_name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
 'city': ['New York', 'London', 'Tokyo', 'Sydney', 'Berlin']
})

# Demographic Information Data
df_demographics = pd.DataFrame({
 'city': ['New York', 'London', 'Tokyo', 'Sydney', 'Berlin'],
 'population': [8419000, 8982000, 13960000, 5312000, 3769000],
 'average_income': [75000, 65000, 85000, 90000, 55000]
})

# Merge Customer Data with Demographic Information
df_customer_demographics = pd.merge(df_customers, df_demographics, on='city', how='left')
print(df_customer_demographics)

Rezultatas:

               customer_id customer_name      city  population  average_income
0            1         Alice  New York     8419000           75000
1            2           Bob    London     8982000           65000
2            3       Charlie     Tokyo    13960000           85000
3            4         David    Sydney     5312000           90000
4            5           Eve    Berlin     3769000           55000

Gautas „DataFrame“ `df_customer_demographics` apima klientų duomenis kartu su demografine informacija apie jų atitinkamus miestus, leidžiančią analizuoti klientų elgseną pagal miesto demografiją.

Globalios tiekimo grandinės duomenų analizavimas

Pandas sujungimas yra vertingas analizuojant globalios tiekimo grandinės duomenis, kur informacija dažnai yra išskaidyta per kelias lenteles. Pavyzdžiui, susiejant tiekėjų duomenis, pristatymo informaciją ir pardavimų rodiklius galima nustatyti kliūtis ir optimizuoti logistiką.

Pavyzdys:

            # Supplier Data
df_suppliers = pd.DataFrame({
 'supplier_id': [1, 2, 3],
 'supplier_name': ['GlobalTech', 'EuroParts', 'AsiaSource'],
 'location': ['Taiwan', 'Germany', 'China']
})

# Shipping Data
df_shipments = pd.DataFrame({
 'shipment_id': [101, 102, 103, 104],
 'supplier_id': [1, 2, 3, 1],
 'destination': ['USA', 'Canada', 'Australia', 'Japan'],
 'shipment_date': ['2023-01-10', '2023-02-15', '2023-03-20', '2023-04-25']
})


# Merge Supplier and Shipment Data
df_supply_chain = pd.merge(df_shipments, df_suppliers, on='supplier_id', how='left')

print(df_supply_chain)

Rezultatas:

               shipment_id  supplier_id destination shipment_date supplier_name location
0          101            1         USA    2023-01-10     GlobalTech   Taiwan
1          102            2      Canada    2023-02-15      EuroParts  Germany
2          103            3   Australia    2023-03-20     AsiaSource    China
3          104            1       Japan    2023-04-25     GlobalTech   Taiwan

Pažangios sujungimo technikos

Sujungimas pagal kelis stulpelius

Galite sujungti „DataFrames“ pagal kelis stulpelius, perduodami stulpelių pavadinimų sąrašą `on` parametrui.

Pavyzdys:

            # DataFrame 1
df1 = pd.DataFrame({
 'product_id': [1, 1, 2, 2],
 'color': ['red', 'blue', 'red', 'blue'],
 'quantity': [10, 15, 20, 25]
})

# DataFrame 2
df2 = pd.DataFrame({
 'product_id': [1, 1, 2, 2],
 'color': ['red', 'blue', 'red', 'blue'],
 'price': [5, 7, 8, 10]
})

# Merge on multiple columns
df_merged_multiple = pd.merge(df1, df2, on=['product_id', 'color'], how='inner')
print(df_merged_multiple)

Rezultatas:

               product_id color  quantity  price
0           1   red        10      5
1           1  blue        15      7
2           2   red        20      8
3           2  blue        25     10

Sujungimas su skirtingais stulpelių pavadinimais

Jei sujungimo stulpeliai turi skirtingus pavadinimus dviejuose „DataFrames“, galite naudoti `left_on` ir `right_on` parametrus, norėdami nurodyti stulpelių pavadinimus, kurie bus naudojami sujungimui.

Pavyzdys:

            # DataFrame 1
df1 = pd.DataFrame({
 'product_id': [1, 2, 3],
 'product_name': ['Product A', 'Product B', 'Product C']
})

# DataFrame 2
df2 = pd.DataFrame({
 'id': [1, 2, 4],
 'price': [10, 20, 25]
})

# Merge with different column names
df_merged_different = pd.merge(df1, df2, left_on='product_id', right_on='id', how='left')
print(df_merged_different)

Rezultatas:

               product_id product_name   id   price
0           1    Product A  1.0    10.0
1           2    Product B  2.0    20.0
2           3    Product C  NaN     NaN

`indicator` naudojimas sujungimo analizei

Parametras `indicator` funkcijoje `pd.merge()` prideda stulpelį pavadinimu `_merge` į gautą „DataFrame“, nurodantį kiekvienos eilutės šaltinį. Tai naudinga norint suprasti, kurios eilutės buvo suderintos, o kurios ne.

Pavyzdys:

            # Merge with indicator
df_merged_indicator = pd.merge(df_orders, df_customers, on='customer_id', how='outer', indicator=True)
print(df_merged_indicator)

Rezultatas:

               order_id  customer_id  product_id  quantity customer_name    country      _merge
0       1.0          101         1.0       2.0         Alice        USA        both
1       2.0          102         2.0       1.0           Bob     Canada        both
2       3.0          103         1.0       3.0       Charlie         UK        both
3       4.0          104         3.0       1.0           NaN        NaN   left_only
4       5.0          105         2.0       2.0           NaN        NaN   left_only
5       NaN          106         NaN       NaN         David   Australia  right_only

Stulpelis `_merge` nurodo, ar eilutė yra iš abiejų „DataFrames“ (`both`), tik iš kairiojo „DataFrame“ (`left_only`), ar tik iš dešiniojo „DataFrame“ (`right_only`).

Sujungimo tipų tikrinimas

Parametras `validate` užtikrina, kad sujungimo operacija atitiktų numatomus ryšių tipus tarp „DataFrames“ (pvz., 'one_to_one', 'one_to_many'). Tai padeda išvengti duomenų nenuoseklumo ir klaidų.

Pavyzdys:

            # Example with one-to-one validation
df_users = pd.DataFrame({
 'user_id': [1, 2, 3],
 'username': ['john_doe', 'jane_smith', 'peter_jones']
})

df_profiles = pd.DataFrame({
 'user_id': [1, 2, 3],
 'profile_description': ['Software Engineer', 'Data Scientist', 'Project Manager']
})

# Performing a one-to-one merge with validation
merged_df = pd.merge(df_users, df_profiles, on='user_id', validate='one_to_one')

print(merged_df)

Jei sujungimas pažeidžia nurodytą patvirtinimą (pvz., ryšys "daug su vienu", kai nurodytas "vienas su vienu"), bus iškelta `MergeError` klaida, įspėjanti apie galimas duomenų vientisumo problemas.

Veikimo aspektai

„DataFrames“ sujungimas ir apjungimas gali būti skaičiavimo prasme brangus, ypač dideliems duomenų rinkiniams. Štai keletas patarimų, kaip pagerinti veikimą:

Naudokite tinkamą sujungimo tipą: Pasirinkus tinkamą sujungimo tipą, galima žymiai pagerinti veikimą. Pavyzdžiui, jei jums reikia tik sutampančių eilučių, naudokite vidinį sujungimą.
Indeksuokite sujungimo stulpelius: Sujungimo stulpelių indeksavimas gali pagreitinti sujungimo procesą.
Naudokite tinkamus duomenų tipus: Užtikrinkite, kad sujungimo stulpeliai turėtų suderinamus duomenų tipus.
Venkite nereikalingų kopijų: Nustatykite `copy=False` `pd.merge()` ir `df.join()` funkcijose, kad išvengtumėte nereikalingų duomenų kopijų kūrimo.

Išvada

„DataFrames“ sujungimas ir apjungimas yra pagrindinės duomenų analizės operacijos. Suprasdami skirtingus sujungimo tipus ir technikas, galite efektyviai derinti ir analizuoti duomenis iš įvairių šaltinių, atskleisdami vertingas įžvalgas ir skatindami pagrįstą sprendimų priėmimą. Nuo pardavimų duomenų sujungimo su produkto informacija iki globalių tiekimo grandinių analizės, šių technikų įvaldymas suteiks jums galimybę su pasitikėjimu spręsti sudėtingas duomenų manipuliavimo užduotis. Nepamirškite atsižvelgti į veikimo pasekmes dirbant su dideliais duomenų rinkiniais ir pasinaudoti pažangiomis funkcijomis, tokiomis kaip `indicator` ir `validate` parametrai, kad atliktumėte patikimesnę ir įžvalgesnę analizę.